unit WinSvcUtils;

interface

uses
  Windows, WinSvc;

const
  bit29 = 1 SHL 28;

  NERR_Success = 0;
  NERR_BASE = 2100;
  NERR_NameNotFound = NERR_BASE + 173;
  NERR_NetworkError = NERR_BASE + 36;
  ERROR_FAILED_STARTING_SERVICE = 1 or bit29;
  ERROR_FAILED_STOPPING_SERVICE = 2 or bit29;

function ServiceGetStatus(sMachine, sService: PChar): DWORD; 
function ServiceRunning(sMachine, sService: PChar): Boolean;
function ServiceStop(Machine, ServiceName: string): Boolean;
function ServiceStart(Machine, ServiceName: string): Boolean;

implementation

//////////////////////////////////////////////////////////////////////////////// 
// Procedure : ServiceGetStatus 
// Comment   : Author: DieHardMan 

function ServiceGetStatus(sMachine, sService: PChar): DWORD; 
  {******************************************} 
  {*** Parameters: ***} 
  {*** sService: specifies the name of the service to open 
  {*** sMachine: specifies the name of the target computer 
  {*** ***} 
  {*** Return Values: ***} 
  {*** -1 = Error opening service ***} 
  {*** 1 = SERVICE_STOPPED ***} 
  {*** 2 = SERVICE_START_PENDING ***} 
  {*** 3 = SERVICE_STOP_PENDING ***} 
  {*** 4 = SERVICE_RUNNING ***} 
  {*** 5 = SERVICE_CONTINUE_PENDING ***} 
  {*** 6 = SERVICE_PAUSE_PENDING ***} 
  {*** 7 = SERVICE_PAUSED ***} 
  {******************************************} 
var 
  SCManHandle, SvcHandle: SC_Handle; 
  SS: TServiceStatus; 
  dwStat: DWORD; 
begin 
  dwStat := 0; 
  // Open service manager handle. 
  SCManHandle := OpenSCManager(sMachine, nil, SC_MANAGER_CONNECT); 
  if (SCManHandle > 0) then 
  begin 
    SvcHandle := OpenService(SCManHandle, sService, SERVICE_QUERY_STATUS); 
    // if Service installed 
    if (SvcHandle > 0) then 
    begin 
      // SS structure holds the service status (TServiceStatus); 
      if (QueryServiceStatus(SvcHandle, SS)) then 
        dwStat := ss.dwCurrentState; 
      CloseServiceHandle(SvcHandle); 
    end; 
    CloseServiceHandle(SCManHandle); 
  end; 
  Result := dwStat; 
end; 

function ServiceRunning(sMachine, sService: PChar): Boolean;
begin
  Result := SERVICE_RUNNING = ServiceGetStatus(sMachine, sService); 
end; 


function ServiceStart(Machine, ServiceName: string): Boolean;
// Machine is UNC path or local machine if empty 
var 
  h_manager, h_svc: SC_Handle; 
  ServiceStatus: TServiceStatus; 
  dwCheckPoint: DWORD; 
  ServiceArgVectors: PChar; 
begin 
  h_manager := OpenSCManager(PChar(Machine), nil, SC_MANAGER_CONNECT); 
  if h_manager > 0 then 
  begin 
    h_svc := OpenService(h_manager, PChar(ServiceName), 
      SERVICE_START or SERVICE_QUERY_STATUS or SC_MANAGER_ALL_ACCESS); 
    if h_svc > 0 then 
    begin 
      if (StartService(h_svc, 0, ServiceArgVectors)) then { succeeded } 
      begin 
        if (QueryServiceStatus(h_svc, ServiceStatus)) then 
        begin 
          while (SERVICE_RUNNING <> ServiceStatus.dwCurrentState) do 
          begin 
            dwCheckPoint := ServiceStatus.dwCheckPoint; 
            Sleep(ServiceStatus.dwWaitHint); 
            if (not QueryServiceStatus(h_svc, ServiceStatus)) then 
              // couldn't check status 
              break; 
            if (ServiceStatus.dwCheckPoint < dwCheckPoint) then 
              break; 
          end; 
        end; 
      end; 
      CloseServiceHandle(h_svc); 
    end; 
    CloseServiceHandle(h_manager); 
  end; 

  Result := (SERVICE_RUNNING = ServiceStatus.dwCurrentState); 
end; 

function ServiceStop(Machine, ServiceName: string): Boolean;
// Machine is UNC path or local machine if empty
var 
  h_manager, h_svc: SC_Handle; 
  ServiceStatus: TServiceStatus; 
  dwCheckPoint: DWORD; 
begin 
  h_manager := OpenSCManager(PChar(Machine), nil, SC_MANAGER_CONNECT); 
  if h_manager > 0 then 
  begin 
    h_svc := OpenService(h_manager, PChar(ServiceName), 
      SERVICE_STOP or SERVICE_QUERY_STATUS); 
    if h_svc > 0 then 
    begin 
      if (ControlService(h_svc, SERVICE_CONTROL_STOP, ServiceStatus)) then 
      begin 
        if (QueryServiceStatus(h_svc, ServiceStatus)) then 
        begin 
          while (SERVICE_STOPPED <> ServiceStatus.dwCurrentState) do 
          begin 
            dwCheckPoint := ServiceStatus.dwCheckPoint; 
            Sleep(ServiceStatus.dwWaitHint); 
            if (not QueryServiceStatus(h_svc, ServiceStatus)) then 
              // couldn't check status 
              break; 
            if (ServiceStatus.dwCheckPoint < dwCheckPoint) then 
              break; 
          end; 
        end; 
      end; 
      CloseServiceHandle(h_svc); 
    end; 
    CloseServiceHandle(h_manager); 
  end; 

  Result := (SERVICE_STOPPED = ServiceStatus.dwCurrentState); 
end;

end.
